// 优化后的用户管理控制器
const User = require('../models/userModel');
const Role = require('../models/roleModel');
const bcrypt = require('bcryptjs');
// 导入缓存服务和缓存键生成工具
const cacheService = require('../cache/cacheService');
const { generateCacheKey, getCacheKeyPattern, generatePermissionCacheKey } = require('../cache/utils/cacheKeyGenerator');
const { success, error, serverError, notFound, badRequest } = require('../utils/response');
const { getLogger } = require('../logger');
const logger = getLogger('controllers.userController');
const { logAudit } = require('../utils/auditLogger');
const { validateRequired, validateUsername, validatePassword, validateMobile, validateId, validateArray, validateEmail } = require('../utils/validator');
const { isSuperAdminById } = require('../utils/utils');

// 获取所有用户
const getAllUsers = async (req, res) => {
    try {
        const page = parseInt(req.query.page) || 1;
        const limit = parseInt(req.query.limit) || 10;
        const filters={};
        if (req.query.is_delete !== undefined) {
            filters.is_delete = req.query.is_delete === 'true' ? 1 : 0;
        }
        if (req.query.username) {
            filters.username = req.query.username;
        }

        // 搜索值
        if (req.query.searchvalue) {
            filters.searchvalue = req.query.searchvalue;
        }

        // 生成缓存键，使用统一的缓存键生成工具
        const cacheKey = generateCacheKey('user', 'list', JSON.stringify({ page, limit, filters }));
        
        // 尝试从缓存获取数据
        const cachedData = await cacheService.get(cacheKey);
        if (cachedData) {
            logger.info('从缓存获取用户列表数据', { page, limit, filters });
            await logAudit(req, {
                action_type: 'view',
                module_code: 'user',
                business_type: 'list',
                operation_desc: 'list'
            });
            return success(req, res, '获取用户列表成功', cachedData);
        }

        // 从认证中间件获取当前用户ID
        const currentUserId = req.user?.id;
        
        const [users, total] = await Promise.all([
            User.getAllUsers(page, limit, filters, currentUserId),
            User.getUserCount(filters, currentUserId)
        ]);

        const responseData = {
            data: users,
            pagination: {
                page,
                limit,
                total,
                pages: Math.ceil(total / limit)
            }
        };
        
        // 将结果存入缓存，使用策略参数
        await cacheService.set(cacheKey, responseData, null, 'permission.list');
        logger.info('将用户列表数据存入缓存', { page, limit, filters });

        await logAudit(req, {
            action_type: 'view',
            module_code: 'user',
            business_type: 'list',
            operation_desc: 'list'
        });
        success(req, res, '获取用户列表成功', responseData);
    } catch (err) {
        logger.error('获取用户列表错误', { error: err });
        serverError(req, res, '获取用户列表失败');
    }
};

// 获取用户信息
const getUser = async (req, res) => {
    const { id } = req.params;
    try {
        if (!validateId(id)) {
            return badRequest(req, res, '用户ID格式错误');
        }

        // 生成缓存键，使用统一的缓存键生成工具
        const cacheKey = generateCacheKey('user', 'item', id);
        
        // 尝试从缓存获取数据
        const cachedData = await cacheService.get(cacheKey);
        if (cachedData) {
            logger.info('从缓存获取用户详情数据', { userId: id });
            await logAudit(req, {
                action_type: 'view',
                module_code: 'user',
                business_type: 'detail',
                operation_desc: 'detail',
                target_entity_type: 'user',
                target_entity_id: id
            });
            return success(req, res, '获取用户信息成功', cachedData);
        }

        const currentUserId = req.user?.id;
        const userinfo = await User.findById(id, currentUserId);
        
        if (!userinfo) {
            return notFound(req, res, '用户不存在');
        }

        // 将结果存入缓存，使用策略参数
        await cacheService.set(cacheKey, userinfo, null, 'user.item');
        logger.info('将用户详情数据存入缓存', { userId: id });

        await logAudit(req, {
            action_type: 'view',
            module_code: 'user',
            business_type: 'detail',
            operation_desc: 'detail',
            target_entity_type: 'user',
            target_entity_id: id
        });
        success(req, res, '获取用户信息成功', userinfo);
    } catch (err) {
        logger.error('获取用户信息错误', { error: err });
        serverError(req, res, '获取用户信息失败');
    }
};

// 创建用户
const createUser = async (req, res) => {
    const { username, password, roleIds, name,email, phone,address,address_ids, detail_address, code ,department_id,avatar_url} = req.body;
    try {
        // 输入验证
        const requiredValidation = validateRequired(req.body, ['username', 'password', 'name','department_id','phone','gender']);
        if (!requiredValidation.isValid) {
            return badRequest(req, res, requiredValidation.message);
        }

        // 用户名格式验证
        const usernameValidation = validateUsername(username);
        if (!usernameValidation.isValid) {
            return badRequest(req, res, usernameValidation.message);
        }

        // 密码强度验证
        const passwordValidation = validatePassword(password);
        if (!passwordValidation.isValid) {
            return badRequest(req, res, passwordValidation.message);
        }

        // 手机号验证（如果提供）
        if (phone && !validateMobile(phone)) {
            return badRequest(req, res, '手机号格式错误');
        }

        // 邮箱验证（如果提供）
        if (email && !validateEmail(email)) {
            return badRequest(req, res, '邮箱格式错误');
        }

        // 验证roleIds数组
        if(roleIds && roleIds.length > 0){
            const roleIdValidation = validateArray(roleIds);
            if (!roleIdValidation.isValid) {
                return badRequest(req, res, roleIdValidation.message);
            }
        }

        // 检查用户名是否已存在
        const existingUser = await User.findByUsername(username);
        if (existingUser) {
            return badRequest(req, res, '用户名已存在');
        }



        // 检查角色是否存在
        if (roleIds && roleIds.length > 0) {
            for (const roleId of roleIds) {
                const existingRole = await Role.findById(roleId);
                if (!existingRole) {
                    return badRequest(req, res, `角色ID ${roleId} 不存在`);
                }
            }
        }


        // 从认证中间件获取当前用户ID
        const currentUserId = req.user?.id;
        
        // 从body获取参数
        const params = {
            ...req.body,
        };
        
        
        const userId = await User.create(params, currentUserId);
        
        // 绑定角色到新创建的用户
        if (roleIds) {
            await User.bindRoles(userId, roleIds,currentUserId, 'insert');
            // 直接设置用户角色缓存，避免下次请求时重建缓存
            await cacheService.set(generateCacheKey('user','roles', userId), roleIds, 7200);
        }
        
        await logAudit(req, {
            action_type: 'create',
            module_code: 'user',
            business_type: 'user',
            operation_desc: 'create',
            target_entity_type: 'user',
            target_entity_id: userId,
            target_entity_name: params.name,
            after_data: params
        });
        success(req, res, '用户创建成功', {
            id: userId, 
            ...params
        });
    } catch (err) {
        logger.error('创建用户错误', { error: err });
        serverError(req, res, '创建用户失败');
    }
};


// 仅更新个人信息
const updateUserInfo = async (req, res) => {
    
    const  currentUserId  = req.user.id;
    const {id,username, name,address='', phone,address_ids='', detail_address='' ,email} = req.body;

    // 验证用户ID格式
    if (!validateId(id)) {
        return badRequest(req, res, '用户ID格式错误');
    }

    // 验证用户ID是否与当前登录用户ID匹配
    if(id!==currentUserId){
        return badRequest(req, res, '不能修改其他用户信息');
    }

    const existingUser = await User.findById(id, currentUserId);
    if (!existingUser) {
        return notFound(req, res, '用户不存在');
    }

    // 如果提供了新用户名，验证格式和唯一性
    if (username && username !== existingUser.username) {
        const usernameValidation = validateUsername(username);
        if (!usernameValidation.isValid) {
            return badRequest(req, res, usernameValidation.message);
        }

        const duplicateUser = await User.findByUsername(username);
        if (duplicateUser) {
            return badRequest(req, res, '用户名已存在');
        }
    }

    // 如果提供了手机号，验证格式
    if (phone && !validateMobile(phone)) {
        return badRequest(req, res, '手机号格式错误');
    }

        // 邮箱验证（如果提供）
    if (email && !validateEmail(email)) {
        return badRequest(req, res, '邮箱格式错误');
    }

    // 检查是否为受保护用户，只有超级管理员可以修改
    const isCurrentUserSuperAdmin = await isSuperAdminById(currentUserId);
    if (existingUser.is_protected === 1 && !isCurrentUserSuperAdmin) {
        return badRequest(req, res, '超级管理员暂未开放修改');
    }

    // 可更新的字段
    const params = {
        id,
        username, 
        name,
        // address, 
        phone,
        // address_ids, 
        // detail_address,
        email
    };

    try {
        await User.update(id, params, currentUserId);
        success(req, res, '用户个人信息更新成功');
    } catch (err) {
        logger.error('更新用户个人信息错误', { error: err });
        serverError(req, res, '更新用户信息失败');
    }

}

// 更新用户
const updateUser = async (req, res) => {
    // 从params或body获取id，增加兼容性
    let { id } = req.params;
    if(!id) {
        id = req.body.id;
    }
    const {username,roleIds, name,address, phone, rolename ,department_id,avatar_url,address_ids, detail_address ,email} = req.body;

    try {
        if (!validateId(id)) {
            return badRequest(req, res, '用户ID格式错误');
        }

        // 验证roleIds数组
        if(roleIds && roleIds.length > 0){
            const roleIdValidation = validateArray(roleIds);
            if (!roleIdValidation.isValid) {
                return badRequest(req, res, roleIdValidation.message);
            }
        }

        // 从认证中间件获取当前用户ID
        const currentUserId = req.user?.id;
        const existingUser = await User.findById(id, currentUserId);
        if (!existingUser) {
            return notFound(req, res, '用户不存在');
        }

        // 如果提供了新用户名，验证格式和唯一性
        if (username && username !== existingUser.username) {
            const usernameValidation = validateUsername(username);
            if (!usernameValidation.isValid) {
                return badRequest(req, res, usernameValidation.message);
            }

            const duplicateUser = await User.findByUsername(username);
            if (duplicateUser) {
                return badRequest(req, res, '用户名已存在');
            }
        }

        // 如果提供了新密码，验证强度
        // if (password) {
        //     const passwordValidation = validatePassword(password);
        //     if (!passwordValidation.isValid) {
        //         return badRequest(req, res, passwordValidation.message);
        //     }
        // }

        // 如果提供了手机号，验证格式
        if (phone && !validateMobile(phone)) {
            return badRequest(req, res, '手机号格式错误');
        }

         // 邮箱验证（如果提供）
        if (email && !validateEmail(email)) {
            return badRequest(req, res, '邮箱格式错误');
        }


        // 检查角色是否存在
        if (roleIds && roleIds.length > 0) {
            for (const roleId of roleIds) {
                const existingRole = await Role.findById(roleId);
                if (!existingRole) {
                    return badRequest(req, res, `角色ID ${roleId} 不存在`);
                }
            }
        }


        // 检查是否为受保护用户，只有超级管理员可以修改
        const isCurrentUserSuperAdmin = await isSuperAdminById(currentUserId);
        if (existingUser.is_protected === 1 && !isCurrentUserSuperAdmin) {
            return badRequest(req, res, '超级管理员暂未开放修改');
        }

        // 从body获取参数
        const params = {
            ...req.body,
        };

        const updatedUser = await User.update(id, params, currentUserId);
        
        // 如果提供了roleIds，则更新用户角色绑定
        if (roleIds !== undefined) {
            // 更新角色绑定（'update'模式会先删除现有绑定再添加新绑定）
            await User.bindRoles(id, roleIds, currentUserId, 'update');
            // 清除用户角色缓存
            await cacheService.del(generateCacheKey('user','roles', id));
        }
        
        // 清除用户详情缓存
        await cacheService.del(generateCacheKey('user','item', id));
        logger.info('清除用户详情缓存', { userId: id });
        
        // 清除用户列表缓存（使用通配符模式）
        await cacheService.clearByPattern(getCacheKeyPattern('user','list'));
        logger.info('清除用户列表缓存');
        
        // 如果更新了部门信息，清除部门用户统计缓存
        if (params.department_id) {
            await cacheService.del(generateCacheKey('department','stats', params.department_id));
            if (existingUser.department_id && existingUser.department_id !== params.department_id) {
                await cacheService.del(generateCacheKey('department','stats', existingUser.department_id));
            }
        }
        
        await logAudit(req, {
            action_type: 'update',
            module_code: 'user',
            business_type: 'user',
            operation_desc: 'update',
            target_entity_type: 'user',
            target_entity_id: id,
            target_entity_name: updatedUser.name,
            before_data: existingUser,
            after_data: updatedUser
        });
        success(req, res, '用户更新成功', updatedUser);
    } catch (err) {
        logger.error('更新用户错误', { error: err });
        serverError(req, res, '更新用户失败');
    }
};

// 删除用户
const removeUser = async (req, res) => {
    // 从params或body获取id，增加兼容性
    let { id } = req.params;
    if(!id) {
        id = req.body.id;
    }

    try {
        if (!validateId(id)) {
            return badRequest(req, res, '用户ID格式错误');
        }

        // 从认证中间件获取当前用户ID
        const currentUserId = req.user?.id;
        
        // 检查用户是否存在
        const existingUser = await User.findById(id, currentUserId);
        if (!existingUser) {
            return notFound(req, res, '用户不存在');
        }

        // 检查是否为受保护用户，只有超级管理员可以删除
        const isCurrentUserSuperAdmin = await isSuperAdminById(currentUserId);
        if (existingUser.is_protected === 1 && !isCurrentUserSuperAdmin) {
            return badRequest(req, res, '受保护用户暂未开放删除');
        }

        // 检查是否为部门负责人
        const isDepartmentManager = await User.isDepartmentManager(id);
        if (isDepartmentManager) {
            return badRequest(req, res, '该用户是部门负责人，请先解除部门负责人绑定后再删除');
        }
        
        // 删除用户
        const deletedRows = await User.deleteById(id, currentUserId);
        
        // 删除用户角色关联数据
        await Role.deleteByUserId(id);
        
        // 清除用户角色缓存
        await cacheService.clearByPattern(`user_roles:${id}`);
        
        // 使用缓存服务清除用户详情缓存
        await cacheService.delete(`users:detail:${id}`);
        logger.info('清除用户详情缓存', { userId: id });
        
        // 清除用户列表缓存（使用通配符模式）
        await cacheService.clearByPattern('users:list:*');
        logger.info('清除用户列表缓存');
        
        // 如果有部门信息，清除部门用户统计缓存
        if (existingUser.department_id) {
            await cacheService.del(`department_user_count:${existingUser.department_id}`);
        }

        await logAudit(req, {
            action_type: 'delete',
            module_code: 'user',
            business_type: 'user',
            operation_desc: 'delete',
            target_entity_type: 'user',
            target_entity_id: id,
            target_entity_name: existingUser.name,
            before_data: existingUser
        });
        success(req, res, '用户删除成功');
    } catch (err) {
        logger.error('删除用户错误', { error: err });
        serverError(req, res, '删除用户失败');
    }
};


// 批量删除用户
const removeBatchUsers = async (req, res) => {
    // 从认证中间件获取当前用户ID
    const currentUserId = req.user?.id;
    
    // 从body获取参数
    const params = {
        ...req.body,
    };
    
    // 同时支持从请求体和查询参数中获取ids，增加兼容性
    const ids = params.ids || req.query.ids;
    // 如果ids是字符串形式的逗号分隔值，则转换为数组
    const idsArray = Array.isArray(ids) ? ids : (typeof ids === 'string' ? ids.split(',') : []);
    try {
        // 输入验证
        // 验证ids是否存在且不为空
        if (!ids || idsArray.length === 0) {
            return badRequest(req, res, '请提供要删除的用户ID');
        }

        const idsValidation = validateArray(idsArray, '用户ID');
        if (!idsValidation.isValid) {
            return badRequest(req, res, idsValidation.message);
        }

        // 验证所有用户ID格式
        for (const id of idsArray) {
            if (!validateId(id)) {
                return badRequest(req, res, `用户ID ${id} 格式错误`);
            }
        }

        // 检查用户是否存在且可删除
        const deletableChecks = await Promise.all(
            idsArray.map(async (id) => {
                const existingUser = await User.findById(id, currentUserId);
                if (!existingUser) {
                    return { id, valid: false, message: '用户不存在' };
                }
                
                const deletable = await User.isDeletable(id);
                if (!deletable) {
                    return { id, valid: false, message: '该用户受保护，无法删除' };
                }
                
                return { id, valid: true };
            })
        );

        // 检查是否有不可删除的用户
        const invalidUsers = deletableChecks.filter(check => !check.valid);
        if (invalidUsers.length > 0) {
            return badRequest(req, res, `以下用户无法删除: ${invalidUsers.map(u => `ID ${u.id}(${u.message})`).join(', ')}`);
        }

        // 使用Model方法执行批量删除用户及其关联角色
        await User.deleteBatchWithRoles(idsArray, currentUserId);
        logger.info('批量删除用户成功', { ids: idsArray });

        // 清除所有被删除用户的缓存
        for (const id of idsArray) {
            await cacheService.del(generatePermissionCacheKey(id,'codes'));
        }
        
        // 清除可能的部门用户统计缓存
        await cacheService.clearByPattern(getCacheKeyPattern('department','stats'));
        await cacheService.clearByPattern(getCacheKeyPattern('user','stats'));

        await logAudit(req, {
            action_type: 'delete',
            module_code: 'user',
            business_type: 'user',
            operation_desc: 'batch_delete',
            target_entity_type: 'user',
            target_entity_id: idsArray.join(','),
            change_summary: `batch delete ${idsArray.length}`
        });
        success(req, res, '批量删除用户成功', { deletedCount: idsArray.length, deletedIds: idsArray });
    } catch (err) {
        logger.error('批量删除用户错误', { error: err, ids: idsArray });
        serverError(req, res, '批量删除用户失败');
    }
};

// 重置用户密码（管理员操作，直接重置为初始密码123456）
const resetPassword = async (req, res) => {
    // 从params或body获取id，增加兼容性
    let { id } = req.params;
    if(!id) {
        id = req.body.id;
    }

    try {
        
        // 输入验证 - 仅验证用户ID格式
        if (!validateId(id)) {
            return badRequest(req, res, '用户ID格式错误');
        }

        // 从认证中间件获取当前用户ID
        const currentUserId = req.user?.id;
        
        // 检查用户是否存在
        const existingUser = await User.findById(Number(id), currentUserId);
        if (!existingUser) {
            return notFound(req, res, '用户不存在');
        }

        const result = await User.resetPassword(id, currentUserId);
        
        if (result.affectedRows === 0) {
            return badRequest(req, res, '密码重置失败，可能用户被保护或已被删除');
        }

        await logAudit(req, {
            action_type: 'update',
            module_code: 'user',
            business_type: 'user',
            operation_desc: 'resetpwd',
            target_entity_type: 'user',
            target_entity_id: id,
            target_entity_name: existingUser.name
        });
        success(req, res, '密码重置成功', { newpassword: result.newPassword });
    } catch (err) {
        logger.error('重置用户密码错误', { error: err, userId: id });
        serverError(req, res, '密码重置失败');
    }
};

// 修改用户密码（需要验证旧密码）
const changePassword = async (req, res) => {
    // 从认证中间件获取当前用户ID
    const currentUserId = req.user?.id;
    
    // 从body获取参数
    const params = {
        ...req.body,
    };

    try {

        
        // 输入验证
        if (!validateId(currentUserId)) {
            return badRequest(req, res, '用户ID格式错误');
        }

        const requiredValidation = validateRequired(params, ['oldPassword', 'newPassword']);
        if (!requiredValidation.isValid) {
            return badRequest(req, res, requiredValidation.message);
        }

        // 新密码验证
        // if (!params.newPassword || params.newPassword.length < 6 || params.newPassword.length > 16) {
        //     return badRequest(req, res, '新密码长度必须在6-16位之间');
        // }

        // 新密码验证 - 必须包含至少一个大写字母、一个小写字母、一个数字和一个特殊字符
        if (!/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#$%^&*])[A-Za-z\d!@#$%^&*]{6,16}$/.test(params.newPassword)) {
            return badRequest(req, res, '新密码必须包含至少一个大写字母、一个小写字母、一个数字和一个特殊字符');
        }

        // 检查用户是否存在
        const existingUser = await User.findById(currentUserId, currentUserId);
        if (!existingUser) {
            return notFound(req, res, '用户不存在');
        }

        // 验证当前用户只能修改自己的密码
        if (existingUser.id !== currentUserId) {
            return badRequest(req, res, '只能修改自己的密码');
        }

        // 检查是否为受保护用户，只有超级管理员可以修改
        const isCurrentUserSuperAdmin = await isSuperAdminById(currentUserId);
        if (existingUser.is_protected === 1 && !isCurrentUserSuperAdmin) {
            return badRequest(req, res, '超级管理员暂未开放修改');
        }

        // 验证旧密码
        const isPasswordValid = bcrypt.compareSync(params.oldPassword, existingUser.password);
        if (!isPasswordValid) {
            return badRequest(req, res, '旧密码错误');
        }

        // 更新用户密码
        const affectedRows = await User.update(currentUserId, params, currentUserId);
        
        if (affectedRows === 0) {
            return badRequest(req, res, '密码修改失败');
        }
        
        // 清除用户权限缓存和角色缓存
        await cacheService.del(generatePermissionCacheKey(currentUserId,'codes'));
        await cacheService.del(generateCacheKey('user','roles', currentUserId));

        await logAudit(req, {
            action_type: 'update',
            module_code: 'user',
            business_type: 'user',
            operation_desc: 'changepwd',
            target_entity_type: 'user',
            target_entity_id: currentUserId
        });
        success(req, res, '密码修改成功');
    } catch (err) {
        logger.error('修改用户密码错误', { error: err, userId: currentUserId });
        serverError(req, res, '密码修改失败');
    }
};


// 批量绑定角色
const bindRoles = async (req, res) => {
    const { userId, roleIds } = req.body;

    try {
        // 输入验证
        const requiredValidation = validateRequired(req.body, ['userId', 'roleIds']);
        if (!requiredValidation.isValid) {
            return badRequest(req, res, requiredValidation.message);
        }

        if (!validateId(userId)) {
            return badRequest(req, res, '用户ID格式错误');
        }

        const roleIdsValidation = validateArray(roleIds, '角色ID');
        if (!roleIdsValidation.isValid) {
            return badRequest(req, res, roleIdsValidation.message);
        }

        // 验证所有角色ID格式
        for (const roleId of roleIds) {
            if (!validateId(roleId)) {
                return badRequest(req, res, '角色ID格式错误');
            }
        }

        // 从认证中间件获取当前用户ID
        const currentUserId = req.user?.id;

        const roles = await User.bindRoles(userId, roleIds, currentUserId, 'update');
        
        // 清除用户角色缓存
        await cacheService.del(generateCacheKey('user','roles', userId));
        
        await logAudit(req, {
            action_type: 'update',
            module_code: 'role',
            business_type: 'role_bind',
            operation_desc: 'bindroles',
            target_entity_type: 'user',
            target_entity_id: userId,
            after_data: { roleIds }
        });
        success(req, res, '角色绑定成功', roles);
    } catch (err) {
        logger.error('绑定角色错误', { error: err });
        serverError(req, res, '绑定角色失败');
    }
};

// 移除角色绑定
const removeBindRole = async (req, res) => {
    const { id } = req.params;
    
    try {
        // 前置校验1: 验证绑定关系ID格式
        if (!validateId(id)) {
            return badRequest(req, res, '绑定关系ID格式错误');
        }

        // 前置校验2: 检查绑定关系是否存在
        const bindInfo = await User.getBindInfo(id);
        if (!bindInfo) {
            return notFound(req, res, '用户角色绑定关系不存在');
        }
        
        // 前置校验3: 检查用户当前绑定的角色数量
        const roleCount = await User.getBindRoleCount(bindInfo.user_id);
        
        // 如果用户只有一个角色，则不允许解绑
        if (roleCount <= 1) {
            return badRequest(req, res, '用户至少需要保留一个角色，无法解绑所有角色');
        }
        
        // 执行解绑操作
        const result = await User.unbindRole(id);
        
        // 检查解绑结果中的错误标志
        if (result.error) {
            // 根据不同的错误类型返回相应的错误状态
            if (result.message.includes('不存在')) {
                return notFound(req, res, result.message);
            } else {
                return serverError(req, res, result.message);
            }
        }
        
        // 清除对应用户的角色缓存
        await cacheService.clearByPattern(`user_roles:${bindInfo.user_id}`);
        
        await logAudit(req, {
            action_type: 'delete',
            module_code: 'role',
            business_type: 'role_bind',
            operation_desc: 'unbindrole',
            target_entity_type: 'user',
            target_entity_id: bindInfo.user_id,
            before_data: bindInfo
        });
        success(req, res, '角色绑定移除成功', result);
    } catch (err) {
        logger.error('移除角色绑定错误', { error: err, id });
        serverError(req, res, '移除角色绑定失败');
    }
};


// 获取用户已绑定的角色
const getUserBindRoles = async (req, res) => {
    const { id } = req.params;

    const { page, limit } = req.query;
    const filters = {};
    try {
        if (!validateId(Number(id))) {
            return badRequest(req, res, '用户ID格式错误');
        }

        // 获取当前用户ID
        const currentUserId = req.user?.id;
        
        const [roles, total] = await Promise.all([
            User.getBindRoles(Number(id), page, limit, filters),
            User.getBindRoleCount(Number(id), filters)
        ]);

        success(req, res, '获取用户绑定角色成功', {
            data:roles,
            pagination: {
                page,
                limit,
                total,
                pages: Math.ceil(total / limit)
            }
        });
    } catch (err) {
        logger.error('查询用户已绑定角色错误', { error: err, id });
        serverError(req, res, '查询用户已绑定角色失败');
    }
};


module.exports = {
    bindRoles,
    removeUser,
    updateUser,
    updateUserInfo,
    createUser,
    getUser,
    getAllUsers,
    removeBindRole,
    removeBatchUsers,
    resetPassword,
    changePassword,
    getUserBindRoles
};
